//package com.zyt.springboot.jiamibao;
//
//import com.alibaba.fastjson.JSONObject;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.codec.binary.Base64;
//import org.bouncycastle.jce.provider.BouncyCastleProvider;
//import org.springframework.beans.factory.InitializingBean;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.stereotype.Component;
//
//import javax.crypto.Cipher;
//import java.security.*;
//import java.security.interfaces.RSAPrivateKey;
//import java.security.interfaces.RSAPublicKey;
//import java.security.spec.PKCS8EncodedKeySpec;
//import java.security.spec.X509EncodedKeySpec;
//import java.util.HashMap;
//import java.util.Map;
//@Slf4j
//@Component
//public class RSAUtil implements InitializingBean {
//
//    /**
//     * 定义公钥算法
//     */
//    @Value("${rsautil.keyRsaPublickey}")
//    public String rsaKey;
//
//    /**
//     * 定义公钥算法
//     */
//    @Value("${rsautil.keyRsaPrivatekey}")
//    public String privateKey;
//
//    private static String KEY_RSA_PUBLICKEY;
//    /**
//     * 定义加密方式
//     */
//    private final static String KEY_RSA = "RSA";
//    /**
//     * 定义签名算法
//     */
//    private final static String KEY_RSA_SIGNATURE = "MD5withRSA";
//    /**
//     * 定义私钥算法
//     */
//    private static String KEY_RSA_PRIVATEKEY;
//
//    @Override
//    public void afterPropertiesSet() {
//        KEY_RSA_PUBLICKEY = this.rsaKey;
//        KEY_RSA_PRIVATEKEY = this.privateKey;
//    }
//
//    static {
//        Security.addProvider(new BouncyCastleProvider());
//    }
//
//    /**
//     * 初始化密钥
//     */
//    public static Map<String, Object> init() {
//        Map<String, Object> map = null;
//        try {
//            KeyPairGenerator generator = KeyPairGenerator.getInstance(KEY_RSA);
//            generator.initialize(2048);
//            KeyPair keyPair = generator.generateKeyPair();
//            // 公钥
//            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
//            // 私钥
//            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
//            // 将密钥封装为map
//            map = new HashMap<>();
//            map.put(KEY_RSA_PUBLICKEY, publicKey);
//            map.put(KEY_RSA_PRIVATEKEY, privateKey);
//        } catch (NoSuchAlgorithmException e) {
//            e.printStackTrace();
//        }
//        return map;
//    }
//
//    /**
//     * 公钥加密
//     *
//     * @param data 待加密数据
//     * @param key  公钥
//     */
//    public static byte[] encryptByPublicKey(String data, String key) {
//        byte[] result = null;
//        try {
//            byte[] bytes = decryptBase64(key);
//            // 取得公钥
//            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
//            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
//            PublicKey publicKey = factory.generatePublic(keySpec);
//            // 对数据加密
//            Cipher cipher = Cipher.getInstance("RSA/None/PKCS1Padding", "BC");
//
//            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
//            byte[] encode = cipher.doFinal(data.getBytes());
//            // 再进行Base64加密
//            result = Base64.encodeBase64(encode);//Base64.encode(encode);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return result;
//    }
//
//    /**
//     * 私钥解密
//     *
//     * @param data 加密数据
//     * @param key  私钥
//     */
//    public static String decryptByPrivateKey(byte[] data, String key) {
//        String result = null;
//        try {
//            // 对私钥解密
//            byte[] bytes = decryptBase64(key);
//            // 取得私钥
//            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
//            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
//            PrivateKey privateKey = factory.generatePrivate(keySpec);
//            // 对数据解密
//            Cipher cipher = Cipher.getInstance("RSA/None/PKCS1Padding", "BC");
//            cipher.init(Cipher.DECRYPT_MODE, privateKey);
//            // 先Base64解密
//            byte[] decoded = Base64.decodeBase64(data);
//            result = new String(cipher.doFinal(decoded));
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return result;
//    }
//
//    /**
//     * 获取公钥
//     */
//    public static String getPublicKey(Map<String, Object> map) {
//        String str = "";
//        try {
//            Key key = (Key) map.get(KEY_RSA_PUBLICKEY);
//            str = encryptBase64(key.getEncoded());
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return str;
//    }
//
//    /**
//     * 获取私钥
//     */
//    public static String getPrivateKey(Map<String, Object> map) {
//        String str = "";
//        try {
//            Key key = (Key) map.get(KEY_RSA_PRIVATEKEY);
//            str = encryptBase64(key.getEncoded());
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return str;
//    }
//
//    /**
//     * 用私钥对信息生成数字签名
//     *
//     * @param data       加密数据
//     * @param privateKey 私钥
//     */
//    public static String sign(byte[] data, String privateKey) {
//        String str = "";
//        try {
//            // 解密由base64编码的私钥
//            byte[] bytes = decryptBase64(privateKey);
//            // 构造PKCS8EncodedKeySpec对象
//            PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(bytes);
//            // 指定的加密算法
//            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
//            // 取私钥对象
//            PrivateKey key = factory.generatePrivate(pkcs);
//            // 用私钥对信息生成数字签名
//            Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
//            signature.initSign(key);
//            signature.update(data);
//            str = encryptBase64(signature.sign());
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return str;
//    }
//
//    /**
//     * 校验数字签名
//     *
//     * @param data      加密数据
//     * @param publicKey 公钥
//     * @param sign      数字签名
//     * @return 校验成功返回true，失败返回false
//     */
//    public static boolean verify(byte[] data, String publicKey, String sign) {
//        boolean flag = false;
//        try {
//            // 解密由base64编码的公钥
//            byte[] bytes = decryptBase64(publicKey);
//            // 构造X509EncodedKeySpec对象
//            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
//            // 指定的加密算法
//            KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
//            // 取公钥对象
//            PublicKey key = factory.generatePublic(keySpec);
//            // 用公钥验证数字签名
//            Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
//            signature.initVerify(key);
//            signature.update(data);
//            flag = signature.verify(decryptBase64(sign));
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return flag;
//    }
//
//
//
//    /**
//     * BASE64 解密
//     *
//     * @param key 需要解密的字符串
//     * @return 字节数组
//     */
//    public static byte[] decryptBase64(String key) throws Exception {
//        return Base64.decodeBase64(key);
//    }
//
//    /**
//     * BASE64 加密
//     *
//     * @param key 需要加密的字节数组
//     * @return 字符串
//     */
//    public static String encryptBase64(byte[] key) throws Exception {
//        return new String(Base64.encodeBase64(key));
//    }
//
//    /**
//     * 将二进制转换成16进制
//     *
//     * @param buf
//     * @return
//     */
//    public static String parseByte2HexStr(byte buf[]) {
//        StringBuffer sb = new StringBuffer();
//        for (int i = 0; i < buf.length; i++) {
//            String hex = Integer.toHexString(buf[i] & 0xFF);
//            if (hex.length() == 1) {
//                hex = '0' + hex;
//            }
//            sb.append(hex.toUpperCase());
//        }
//        return sb.toString();
//    }
//
//
//    /**
//     * 将16进制转换为二进制
//     *
//     * @param hexStr
//     * @return
//     */
//    public static byte[] parseHexStr2Byte(String hexStr) {
//        if (hexStr.length() < 1)
//            return null;
//        byte[] result = new byte[hexStr.length() / 2];
//        for (int i = 0; i < hexStr.length() / 2; i++) {
//            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
//            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
//            result[i] = (byte) (high * 16 + low);
//        }
//        return result;
//    }
//    /**
//     * rsa私钥解密后的数据
//     * @param dataSource
//     * @param aesKey
//     * @return
//     */
//    public static JSONObject decryptResponseInfo(String dataSource, String aesKey,String pespRsaPrivateKey,String pespRsaPublicKey)  {
//        JSONObject resJsonObject = new JSONObject();
//        //1.验证数字签名
//        String sign = RSAUtil.sign(aesKey.getBytes(), pespRsaPrivateKey);
//        boolean status = RSAUtil.verify(aesKey.getBytes(), pespRsaPublicKey, sign);
////      数字签名验证通过
//        if(status){
//            byte[] aesKsyBytes = RSAUtil.parseHexStr2Byte(aesKey);
//            aesKey = RSAUtil.decryptByPrivateKey(aesKsyBytes,pespRsaPrivateKey);//rsa解密后的aeskey
//            String data = AesUtil.decrypt(dataSource,aesKey);//aes解密后的数据
//            resJsonObject = JSONObject.parseObject(data);
//        }else {
//            log.error("无法验证数字签名!");
//            resJsonObject.put("errorInfo","无法验证数字签名!");
//        }
//        return resJsonObject;
//
//    }
//
//
//    public static void main(String[] args) throws Exception {
//       System.out.println("公钥加密======私钥解密");
//        String msg = "gaozhen";
////      AesUtil.getRandomString获取10位的aes随机密钥
//        String aeskey = AesUtil.getRandomString(10);
//        System.out.println("aeskey----------------------"+aeskey);
//        //aes加密
//        String msgAESAF = AesUtil.encrypt(msg,aeskey);
//
//        Map<String,Object> map = init();
//        String publicKey = getPublicKey(map);
//        System.out.println("公钥:"+publicKey);
//        String privateKey = getPrivateKey(map);
//        System.out.println("私钥:"+privateKey+":结束");
//        /******************************* 加密 在实际传递报文过程中，需要用对方提供的公钥进行加密 *********/
//        byte[] enStr = RSAUtil.encryptByPublicKey(aeskey, publicKey);
//        String  jiamiStr= parseByte2HexStr(enStr);
//        System.out.println("RSA加密后Str--------------------"+jiamiStr);
//
//        /*****************************  解密 ****************/
//        // 产生签名
//        String sign = sign(jiamiStr.getBytes(), privateKey);
//        System.out.println("签名---------------------------" + sign);
//        // 验证签名
//        boolean status = verify(jiamiStr.getBytes(), publicKey, sign);
//        System.out.println("状态:-------------------------" + status);
//
//        byte[] bytes = parseHexStr2Byte(jiamiStr);
//        String decStr = RSAUtil.decryptByPrivateKey(bytes, privateKey);
//        System.out.println("加密前：" + jiamiStr + "\n\r解密后：" + decStr);
//        String data = AesUtil.decrypt(msgAESAF,decStr);
//        System.out.println("解密后data-------------"+data);
//}
//}
